package com.mine.yyb.common.utils.execl;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Comment;
import org.apache.poi.ss.usermodel.DataFormat;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.IndexedColors;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFClientAnchor;
import org.apache.poi.xssf.usermodel.XSSFRichTextString;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.mine.yyb.common.utils.exception.MineErrorCode;
import com.mine.yyb.common.utils.exception.MineException;
import com.mine.yyb.common.utils.execl.annotation.MineExcelField;
import com.mine.yyb.common.utils.execl.common.MineExcelReflections;

/**
 * 
 * <pre>
 * <一句话功能简述> 
 * 导出Excel文件（导出“XLSX”格式，支持大数据量导出 @see org.apache.poi.ss.SpreadsheetVersion） 
 * <功能详细描述>
 * </pre>
 * 
 * @author 姓名 石彩宝
 * @version [版本号, 2015年10月21日]
 * @see [相关类/方法]
 * @since [产品/模块版本]
 */
public class MineExcelReport
{
    /** 日志对象 */
    private static Logger logger = LoggerFactory.getLogger(MineExcelReport.class);
    
    /**
     * 工作薄对象
     */
    private HSSFWorkbook hssfWorkbook;
    
    /**
     * 工作表对象
     */
    private HSSFSheet hssfSheet;
    
    /**
     * 样式列表
     */
    private Map<String, CellStyle> stylesMap;
    
    /**
     * 是否使用模版（默认不使用模版）
     */
    private boolean templateUsed = false;
    
    /**
     * 模版文件路径
     */
    private String templateFilePath = null;
    
    /**
     * 实体注解Class对象
     */
    private Class<?> tempEntityClass = null;
    
    /**
     * 样式工作表号（仅对根据模版导出有效）
     */
    private int tempSheetNum = 0;
    
    /**
     * 样式模版行号（仅对根据模版导出有效）
     */
    private int tempStyleRownum = 1;
    
    /**
     * 首个插入数据的行号（仅对根据模版导出有效）
     */
    private int firstDataRownum = 2;
    
    /**
     * 是否删除模版行
     */
    private boolean tempRowRemoveRequired = true;
    
    /**
     * 当前行号
     */
    private int rownum;
    
    /**
     * 注解列表（Object[]{ ExcelField, Field/Method }）
     */
    private List<Object[]> annotationList = new ArrayList<Object[]>();
    
    /**
     * 根据模版导出数据
     * 
     * @param templateFilePath-- 模版文件路径
     * @throws MineException--（读入模版文件异常或模版文件未找到）
     */
    public MineExcelReport(String templateFilePath)
        throws MineException
    {
        // 设置模版文件路径
        this.templateFilePath = templateFilePath;
        
        // 根据模版文件进行初始化
        initializeByTemplate();
    }
    
    /**
     * 构造函数
     * 
     * @param title 表格标题，传“空值”，表示无标题
     * @param cls 实体对象，通过annotation.ExportField获取标题
     */
    public MineExcelReport(String title, Class<?> cls)
    {
        this(title, cls, 1);
    }
    
    /**
     * 构造函数
     * 
     * @param title 表格标题，传“空值”，表示无标题
     * @param cls 实体对象，通过annotation.ExportField获取标题
     * @param type 导出类型（1:导出数据；2：导出模板）
     * @param groups 导入分组
     */
    public MineExcelReport(String title, Class<?> cls, int type, int... groups)
    {
        // 初始化注解列表
        List<String> headerList = initAnnotationList(cls, type, groups);
        
        initialize(title, headerList);
    }
    
    /**
     * 构造函数
     * 
     * @param title 表格标题，传“空值”，表示无标题
     * @param headers 表头数组
     */
    public MineExcelReport(String title, String[] headers)
    {
        initialize(title, Arrays.asList(headers));
    }
    
    /**
     * 构造函数
     * 
     * @param title 表格标题，传“空值”，表示无标题
     * @param headerList 表头列表
     */
    public MineExcelReport(String title, List<String> headerList)
    {
        initialize(title, headerList);
    }
    
    /**
     * 
     * <pre>
     * <一句话功能简述>
     * 根据实体类注解初始化表格注解
     * <功能详细描述>
     * </pre>
     * 
     * @author 彭海明
     * @param cls 实体对象，通过annotation.ExportField获取标题
     * @param type 导出类型（1:导出数据；2：导出模板）
     * @param groups 导入分组
     * @return --返回表头列表
     * @see [类、类#方法、类#成员]
     */
    private List<String> initAnnotationList(Class<?> cls, int type, int... groups)
    {
        // Get annotation field
        Field[] fs = cls.getDeclaredFields();
        for (Field f : fs)
        {
            MineExcelField ef = f.getAnnotation(MineExcelField.class);
            if (ef != null && (ef.type() == 0 || ef.type() == type))
            {
                if (groups != null && groups.length > 0)
                {
                    boolean inGroup = false;
                    for (int g : groups)
                    {
                        if (inGroup)
                        {
                            break;
                        }
                        for (int efg : ef.groups())
                        {
                            if (g == efg)
                            {
                                inGroup = true;
                                annotationList.add(new Object[] {ef, f});
                                break;
                            }
                        }
                    }
                }
                else
                {
                    annotationList.add(new Object[] {ef, f});
                }
            }
        }
        // Get annotation method
        Method[] ms = cls.getDeclaredMethods();
        for (Method m : ms)
        {
            MineExcelField ef = m.getAnnotation(MineExcelField.class);
            if (ef != null && (ef.type() == 0 || ef.type() == type))
            {
                if (groups != null && groups.length > 0)
                {
                    boolean inGroup = false;
                    for (int g : groups)
                    {
                        if (inGroup)
                        {
                            break;
                        }
                        for (int efg : ef.groups())
                        {
                            if (g == efg)
                            {
                                inGroup = true;
                                annotationList.add(new Object[] {ef, m});
                                break;
                            }
                        }
                    }
                }
                else
                {
                    annotationList.add(new Object[] {ef, m});
                }
            }
        }
        // Field sorting
        Collections.sort(annotationList, new Comparator<Object[]>()
        {
            public int compare(Object[] o1, Object[] o2)
            {
                return new Integer(((MineExcelField)o1[0]).sort()).compareTo(new Integer(((MineExcelField)o2[0]).sort()));
            };
        });
        // Initialize
        List<String> headerList = new ArrayList<String>();
        for (Object[] os : annotationList)
        {
            String t = ((MineExcelField)os[0]).title();
            // 如果是导出，则去掉注释
            if (type == 1)
            {
                String[] ss = StringUtils.split(t, "**", 2);
                if (ss.length == 2)
                {
                    t = ss[0];
                }
            }
            headerList.add(t);
        }
        
        return headerList;
    }
    
    /**
     * 
     * 根据模版文件执行初始化
     * 
     * @author 彭海明
     * @throws MineException --（读入模版文件异常或模版文件未找到）
     * @see [类、类#方法、类#成员]
     */
    public void initializeByTemplate()
        throws MineException
    {
        try
        {
            // 实体类不为null才执行初始化注解列表
            if (tempEntityClass != null)
            {
                // 初始化注解列表
                initAnnotationList(tempEntityClass, 1);
            }
            
            File templateFile = new File(templateFilePath);
            
            POIFSFileSystem fs = new POIFSFileSystem(new FileInputStream(templateFile));
            
            // 读取excel模板
            this.hssfWorkbook = new HSSFWorkbook(fs);
            
            // 获取模版工作表，默认为excel的第一张（sheetNum=0）工作表
            this.hssfSheet = hssfWorkbook.getSheetAt(tempSheetNum < 0 ? 0 : tempSheetNum);
            
            // 置为使用模版
            this.templateUsed = true;
            
            // 设置模版行的行号
            this.tempStyleRownum = (tempStyleRownum < 0 ? 0 : tempStyleRownum);
            
            // 设置开始插数据的行号，不小于模版行的行号
            this.rownum = (firstDataRownum <= tempStyleRownum ? tempStyleRownum + 1 : firstDataRownum);
            
            logger.debug("Initialize By Template :[{}] success.", templateFilePath);
        }
        catch (Exception e)
        {
            throw new MineException(MineErrorCode.ERROR_EXCEL_REPORT_FAIL, e);
        }
    }
    
    /**
     * 初始化函数
     * 
     * @param title 表格标题，传“空值”，表示无标题
     * @param headerList 表头列表
     */
    private void initialize(String title, List<String> headerList)
    {
        // by PengHM 2015.11.3
        this.hssfWorkbook = new HSSFWorkbook();
        
        // this.hssfWorkbook = new SXSSFWorkbook(500);
        this.hssfSheet = hssfWorkbook.createSheet("Export");
        this.stylesMap = createStyles(hssfWorkbook);
        // Create title
        if (StringUtils.isNotBlank(title))
        {
            Row titleRow = hssfSheet.createRow(rownum++);
            titleRow.setHeightInPoints(30);
            Cell titleCell = titleRow.createCell(0);
            titleCell.setCellStyle(stylesMap.get("title"));
            titleCell.setCellValue(title);
            hssfSheet.addMergedRegion(new CellRangeAddress(titleRow.getRowNum(), titleRow.getRowNum(),
                titleRow.getRowNum(), headerList.size() - 1));
        }
        // Create header
        if (headerList == null)
        {
            throw new RuntimeException("headerList not null!");
        }
        Row headerRow = hssfSheet.createRow(rownum++);
        headerRow.setHeightInPoints(16);
        for (int i = 0; i < headerList.size(); i++)
        {
            Cell cell = headerRow.createCell(i);
            cell.setCellStyle(stylesMap.get("header"));
            String[] ss = StringUtils.split(headerList.get(i), "**", 2);
            if (ss.length == 2)
            {
                cell.setCellValue(ss[0]);
                Comment comment =
                    this.hssfSheet.createDrawingPatriarch().createCellComment(new XSSFClientAnchor(0, 0, 0, 0,
                        (short)3, 3, (short)5, 6));
                comment.setString(new XSSFRichTextString(ss[1]));
                cell.setCellComment(comment);
            }
            else
            {
                cell.setCellValue(headerList.get(i));
            }
            hssfSheet.autoSizeColumn(i);
        }
        for (int i = 0; i < headerList.size(); i++)
        {
            int colWidth = hssfSheet.getColumnWidth(i) * 2;
            hssfSheet.setColumnWidth(i, colWidth < 3000 ? 3000 : colWidth);
        }
        
        logger.debug("Initialize success.");
    }
    
    /**
     * 创建表格样式
     * 
     * @param wb 工作薄对象
     * @return 样式列表
     */
    private Map<String, CellStyle> createStyles(Workbook wb)
    {
        Map<String, CellStyle> styles = new HashMap<String, CellStyle>();
        
        CellStyle style = wb.createCellStyle();
        style.setAlignment(CellStyle.ALIGN_CENTER);
        style.setVerticalAlignment(CellStyle.VERTICAL_CENTER);
        Font titleFont = wb.createFont();
        titleFont.setFontName("Arial");
        titleFont.setFontHeightInPoints((short)16);
        titleFont.setBoldweight(Font.BOLDWEIGHT_BOLD);
        style.setFont(titleFont);
        styles.put("title", style);
        
        style = wb.createCellStyle();
        style.setVerticalAlignment(CellStyle.VERTICAL_CENTER);
        style.setBorderRight(CellStyle.BORDER_THIN);
        style.setRightBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
        style.setBorderLeft(CellStyle.BORDER_THIN);
        style.setLeftBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
        style.setBorderTop(CellStyle.BORDER_THIN);
        style.setTopBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
        style.setBorderBottom(CellStyle.BORDER_THIN);
        style.setBottomBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
        Font dataFont = wb.createFont();
        dataFont.setFontName("Arial");
        dataFont.setFontHeightInPoints((short)10);
        style.setFont(dataFont);
        styles.put("data", style);
        
        style = wb.createCellStyle();
        style.cloneStyleFrom(styles.get("data"));
        style.setAlignment(CellStyle.ALIGN_LEFT);
        styles.put("data1", style);
        
        style = wb.createCellStyle();
        style.cloneStyleFrom(styles.get("data"));
        style.setAlignment(CellStyle.ALIGN_CENTER);
        styles.put("data2", style);
        
        style = wb.createCellStyle();
        style.cloneStyleFrom(styles.get("data"));
        style.setAlignment(CellStyle.ALIGN_RIGHT);
        styles.put("data3", style);
        
        style = wb.createCellStyle();
        style.cloneStyleFrom(styles.get("data"));
        // style.setWrapText(true);
        style.setAlignment(CellStyle.ALIGN_CENTER);
        style.setFillForegroundColor(IndexedColors.GREY_50_PERCENT.getIndex());
        style.setFillPattern(CellStyle.SOLID_FOREGROUND);
        Font headerFont = wb.createFont();
        headerFont.setFontName("Arial");
        headerFont.setFontHeightInPoints((short)10);
        headerFont.setBoldweight(Font.BOLDWEIGHT_BOLD);
        headerFont.setColor(IndexedColors.WHITE.getIndex());
        style.setFont(headerFont);
        styles.put("header", style);
        
        return styles;
    }
    
    // -------------get、set属性开始---------------------------
    
    /**
     * 获取 templateUsed
     * 
     * @return 返回 templateUsed
     */
    public boolean isTemplateUsed()
    {
        return templateUsed;
    }
    
    /**
     * 获取 templateFilePath
     * 
     * @return 返回 templateFilePath
     */
    public String getTemplateFilePath()
    {
        return templateFilePath;
    }
    
    /**
     * 设置 templateFilePath
     * 
     * @param 对templateFilePath进行赋值
     */
    public void setTemplateFilePath(String templateFilePath)
    {
        this.templateFilePath = templateFilePath;
    }
    
    /**
     * 获取 tempEntityClass
     * 
     * @return 返回 tempEntityClass
     */
    public Class<?> getTempEntityClass()
    {
        return tempEntityClass;
    }
    
    /**
     * 设置 tempEntityClass
     * 
     * @param 对tempEntityClass进行赋值
     */
    public void setTempEntityClass(Class<?> tempEntityClass)
    {
        this.tempEntityClass = tempEntityClass;
    }
    
    /**
     * 获取 tempSheetNum
     * 
     * @return 返回 tempSheetNum
     */
    public int getTempSheetNum()
    {
        return tempSheetNum;
    }
    
    /**
     * 设置 tempSheetNum
     * 
     * @param 对tempSheetNum进行赋值
     */
    public void setTempSheetNum(int tempSheetNum)
    {
        this.tempSheetNum = tempSheetNum;
    }
    
    /**
     * 获取 tempStyleRownum
     * 
     * @return 返回 tempStyleRownum
     */
    public int getTempStyleRownum()
    {
        return tempStyleRownum;
    }
    
    /**
     * 设置 tempStyleRownum
     * 
     * @param 对tempStyleRownum进行赋值
     */
    public void setTempStyleRownum(int tempStyleRownum)
    {
        this.tempStyleRownum = tempStyleRownum;
    }
    
    /**
     * 获取 firstDataRownum
     * 
     * @return 返回 firstDataRownum
     */
    public int getFirstDataRownum()
    {
        return firstDataRownum;
    }
    
    /**
     * 设置 firstDataRownum
     * 
     * @param 对firstDataRownum进行赋值
     */
    public void setFirstDataRownum(int firstDataRownum)
    {
        this.firstDataRownum = firstDataRownum;
    }
    
    /**
     * 获取 tempRowRemoveRequired
     * 
     * @return 返回 tempRowRemoveRequired
     */
    public boolean isTempRowRemoveRequired()
    {
        return tempRowRemoveRequired;
    }
    
    /**
     * 设置 tempRowRemoveRequired
     * 
     * @param 对tempRowRemoveRequired进行赋值
     */
    public void setTempRowRemoveRequired(boolean tempRowRemoveRequired)
    {
        this.tempRowRemoveRequired = tempRowRemoveRequired;
    }
    
    // -------------get、set属性结束---------------------------
    
    /**
     * 
     * 删除行
     * 
     * @author 彭海明
     * @param delRownum --删除行的行号
     * @param positionRemoveRequired --是否删除行的位置
     * @see [类、类#方法、类#成员]
     */
    public void delRow(int delRownum, boolean positionRemoveRequired)
    {
        // 删除内容和位置
        if (positionRemoveRequired)
        {
            // 整体向上移动1行，达到删除行的效果
            hssfSheet.shiftRows(delRownum + 1, hssfSheet.getLastRowNum(), -1);
        }
        else
        {
            // 只删除内容
            hssfSheet.removeRow(hssfSheet.getRow(delRownum));
        }
    }
    
    /**
     * 添加一行
     * 
     * @return 行对象
     */
    public Row addRow()
    {
        return hssfSheet.createRow(rownum++);
    }
    
    /**
     * 添加一个单元格
     * 
     * @param row 添加的行
     * @param column 添加列号
     * @param val 添加值
     * @return 单元格对象
     */
    public Cell addCell(Row row, int column, Object val)
    {
        return this.addCell(row, column, val, 0, Class.class);
    }
    
    /**
     * 添加一个单元格
     * 
     * @param row 添加的行
     * @param column 添加列号
     * @param val 添加值
     * @param align 对齐方式（1：靠左；2：居中；3：靠右）
     * @return 单元格对象
     */
    public Cell addCell(Row row, int column, Object val, int align, Class<?> fieldType)
    {
        Cell cell = row.createCell(column);
        
        // 单元格样式
        CellStyle style = null;
        
        // 使用模版行的单元格样式
        if (this.templateUsed)
        {
            style = this.hssfSheet.getRow(this.tempStyleRownum).getCell(column).getCellStyle();
        }
        else
        {
            style = this.stylesMap.get("data" + (align >= 1 && align <= 3 ? align : ""));
        }
        
        try
        {
            if (val == null)
            {
                cell.setCellValue("");
            }
            else if (val instanceof String)
            {
                cell.setCellValue((String)val);
            }
            else if (val instanceof Integer)
            {
                cell.setCellValue((Integer)val);
            }
            else if (val instanceof Long)
            {
                cell.setCellValue((Long)val);
            }
            else if (val instanceof Double)
            {
                cell.setCellValue((Double)val);
            }
            else if (val instanceof Float)
            {
                cell.setCellValue((Float)val);
            }
            else if (val instanceof Date)
            {
                DataFormat format = hssfWorkbook.createDataFormat();
                
                style.setDataFormat(format.getFormat("yyyy-MM-dd"));
                
                cell.setCellValue((Date)val);
            }
            else
            {
                if (fieldType != Class.class)
                {
                    cell.setCellValue((String)fieldType.getMethod("setValue", Object.class).invoke(null, val));
                }
                else
                {
                    cell.setCellValue((String)Class.forName(this.getClass()
                        .getName()
                        .replaceAll(this.getClass().getSimpleName(),
                            "fieldtype." + val.getClass().getSimpleName() + "Type"))
                        .getMethod("setValue", Object.class)
                        .invoke(null, val));
                }
            }
        }
        catch (Exception ex)
        {
            logger.info("Set cell value [" + row.getRowNum() + "," + column + "] error: " + ex.toString());
            
            cell.setCellValue(val.toString());
        }
        
        // 设置单元格样式
        cell.setCellStyle(style);
        
        return cell;
    }
    
    /**
     * 添加数据（通过annotation.ExportField添加数据）
     * 
     * @return list 数据列表
     */
    public <E> MineExcelReport setDataList(List<E> list)
    {
        for (E e : list)
        {
            int colunm = 0;
            Row row = this.addRow();
            StringBuilder sb = new StringBuilder();
            for (Object[] os : annotationList)
            {
                MineExcelField ef = (MineExcelField)os[0];
                Object val = null;
                // Get entity value
                try
                {
                    if (StringUtils.isNotBlank(ef.value()))
                    {
                        val = MineExcelReflections.invokeGetter(e, ef.value());
                    }
                    else
                    {
                        if (os[1] instanceof Field)
                        {
                            val = MineExcelReflections.invokeGetter(e, ((Field)os[1]).getName());
                        }
                        else if (os[1] instanceof Method)
                        {
                            val =
                                MineExcelReflections.invokeMethod(e,
                                    ((Method)os[1]).getName(),
                                    new Class[] {},
                                    new Object[] {});
                        }
                    }
                    // If is dict, get dict label
                    // if (StringUtils.isNotBlank(ef.dictType()))
                    // {
                    // val = DictUtils.getDictLabel(val == null ? "" : val.toString(), ef.dictType(), "");
                    // }
                }
                catch (Exception ex)
                {
                    // Failure to ignore
                    logger.info(ex.toString());
                    val = "";
                }
                this.addCell(row, colunm++, val, ef.align(), ef.fieldType());
                sb.append(val + ", ");
            }
            logger.debug("Write success: [" + row.getRowNum() + "] " + sb.toString());
        }
        return this;
    }
    
    /**
     * 输出数据流
     * 
     * @param os 输出数据流
     */
    public MineExcelReport write(OutputStream os)
        throws IOException
    {
        // 使用了模版且删除模版行
        if (this.templateUsed && this.tempRowRemoveRequired)
        {
            // 删除模版行
            delRow(this.tempStyleRownum, true);
        }
        
        hssfWorkbook.write(os);
        return this;
    }
    
    /**
     * 输出到文件
     * 
     * @param fileName 输出文件名
     */
    public MineExcelReport writeFile(String name)
        throws FileNotFoundException, IOException
    {
        FileOutputStream os = new FileOutputStream(name);
        this.write(os);
        return this;
    }
    
    /**
     * 清理临时文件
     * 
     * @throws IOException
     */
    public MineExcelReport dispose()
        throws IOException
    {
        // by PengHM 2015.11.3
        hssfWorkbook.close();
        
        // hssfWorkbook.dispose();
        return this;
    }
    
    // /**
    // * 导出测试
    // */
    // public static void main(String[] args)
    // {
    //
    // try
    // {
    //
    // List<String> headerList = Lists.newArrayList();
    // for (int i = 1; i <= 10; i++)
    // {
    // headerList.add("表头" + i);
    // }
    //
    // List<String> dataRowList = Lists.newArrayList();
    // for (int i = 1; i <= headerList.size(); i++)
    // {
    // dataRowList.add("数据" + i);
    // }
    //
    // List<List<String>> dataList = Lists.newArrayList();
    // for (int i = 1; i <= 100; i++)
    // {
    // dataList.add(dataRowList);
    // }
    //
    // ExportExcel ee = new ExportExcel("表格标题", headerList);
    //
    // for (int i = 0; i < dataList.size(); i++)
    // {
    // Row row = ee.addRow();
    // for (int j = 0; j < dataList.get(i).size(); j++)
    // {
    // ee.addCell(row, j, dataList.get(i).get(j));
    // }
    // }
    //
    // ee.writeFile("testExport.xlsx");
    //
    // ee.dispose();
    //
    // log.debug("Export success.");
    //
    // }
    // catch (Exception e)
    // {
    // e.printStackTrace();
    // }
    //
    // }
    
}
